"""
重构后的智能体模块
使用LangGraph Supervisor架构实现多智能体协调

备份时间: 2025-01-04
原始版本已备份到 dingding/Agents_backup.py

性能优化: 2025-01-05
- 实现线程安全的单例模式，避免重复初始化
- 优化资源管理和内存使用
"""

from typing import Dict, Any
from .Memory import MemoryClass
from .Storage import get_user, add_user
from .config_manager import ConfigManager, get_config
from dotenv import load_dotenv as _load_dotenv
import os
import asyncio
import logging
import time
import threading
from text2sql.text2sql_tools import get_text2sql_agent
from langgraph_supervisor import create_supervisor
from langgraph.checkpoint.memory import MemorySaver
from langchain_core.messages import HumanMessage, AIMessage

# 导入增强记忆系统
try:
    from enhanced_memory.integrated_agent_class import EnhancedAgentClass, create_enhanced_agent_async
    from enhanced_memory.memory_architecture import MemoryConfig
    ENHANCED_MEMORY_AVAILABLE = True
except ImportError as e:
    logging.warning(f"Enhanced memory system not available: {e}")
    ENHANCED_MEMORY_AVAILABLE = False

_load_dotenv()

# 设置环境变量
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_API_BASE"] = os.getenv("OPENAI_BASE_URL")
os.environ["DEEPSEEK_API_KEY"] = os.getenv("DEEPSEEK_API_KEY")
os.environ["DEEPSEEK_API_BASE"] = os.getenv("DEEPSEEK_API_BASE")

# os.environ["LANGSMITH_TRACING"] = "true"
# os.environ["LANGSMITH_ENDPOINT"] = "https://api.smith.langchain.com"
# os.environ["LANGSMITH_API_KEY"] = "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"
# os.environ["LANGSMITH_PROJECT"] = "supervisor_agent"

# 添加基础缓存
from langchain_core.globals import set_llm_cache
from langchain_core.caches import InMemoryCache
set_llm_cache(InMemoryCache())

# 简化缓存系统：移除复杂的HybridCacheManager
# 保留基础的LangChain缓存和Redis对话记忆
import redis
import hashlib
import json
CACHE_AVAILABLE = True  # 简化版本始终可用


class SingletonMeta(type):
    """
    线程安全的单例元类
    确保在多线程环境下只创建一个实例
    """
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            with cls._lock:
                # 双重检查锁定模式
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]

    @classmethod
    def clear_instances(cls):
        """清除所有单例实例（用于测试或重置）"""
        with cls._lock:
            cls._instances.clear()


class AgentClass(metaclass=SingletonMeta):
    """
    使用LangGraph Supervisor架构进行多智能体协调
    支持增强记忆系统的渐进式升级

    单例模式：确保整个应用生命周期中只有一个实例，避免重复初始化开销
    """

    def __init__(self):
        """初始化智能体类（单例模式，只初始化一次）"""
        # 检查是否已经初始化过
        if hasattr(self, '_initialized') and self._initialized:
            print("♻️ AgentClass 单例已存在，跳过重复初始化")
            return

        print("🚀 初始化 AgentClass 单例实例...")

        # 基础配置
        self.modelname = os.getenv("BASE_MODEL", "gpt-4")
        self.memorykey = os.getenv("MEMORY_KEY", "chat_history")

        # 默认启用增强记忆模式（架构统一）
        self.enhanced_mode = (
            ENHANCED_MEMORY_AVAILABLE and
            os.getenv("ENHANCED_MEMORY", "true").lower() == "true"
        )

        # 增强智能体实例
        self.enhanced_agent = None
        self._enhanced_initialized = False

        # 初始化默认属性（防止属性错误）
        self.cache_enabled = False
        self.cache_manager = None
        self.memory = None  # 确保memory属性存在
        self.app = None     # 确保app属性存在
        self._enhanced_initialized = False

        # 初始化缓存管理器
        self._init_cache_manager()

        # 统一使用增强智能体（保留降级机制）
        if self.enhanced_mode:
            print("🚀 启用增强记忆模式")
            self._init_enhanced_agent()
        else:
            print("📝 增强记忆不可用，使用基础模式")
            self._enhanced_initialized = False
            self._init_basic_agent()

        # 标记为已初始化
        self._initialized = True
        print("✅ AgentClass 单例初始化完成")

    @classmethod
    def get_instance(cls):
        """获取单例实例的类方法"""
        return cls()

    @classmethod
    def reset_instance(cls):
        """重置单例实例（用于测试或重新初始化）"""
        if cls in SingletonMeta._instances:
            instance = SingletonMeta._instances[cls]
            if hasattr(instance, '_initialized'):
                instance._initialized = False
            # 清理资源
            if hasattr(instance, 'cache_manager') and instance.cache_manager:
                try:
                    # 如果有清理方法，调用它
                    if hasattr(instance.cache_manager, 'close'):
                        instance.cache_manager.close()
                except Exception as e:
                    logging.warning(f"清理缓存管理器失败: {e}")

        SingletonMeta.clear_instances()
        print("🔄 AgentClass 单例已重置")

    def is_initialized(self) -> bool:
        """检查是否已初始化"""
        return getattr(self, '_initialized', False)

    def _init_enhanced_agent(self):
        """初始化增强智能体"""
        try:
            # 创建配置
            config = MemoryConfig()

            # 检查是否可以安全初始化
            try:
                # 检查是否有运行中的事件循环
                asyncio.get_running_loop()
                # 如果有运行中的循环，使用同步模式但保持增强功能
                print("⏳ 检测到运行中的事件循环，使用同步增强模式")
                # 不禁用增强模式，而是使用同步方式初始化
                self._init_enhanced_sync()
                return
            except RuntimeError:
                # 没有运行中的事件循环，可以安全初始化
                pass

            # 异步初始化增强智能体
            async def init_async():
                try:
                    self.enhanced_agent = await create_enhanced_agent_async(config)
                    # 设置基础智能体引用以支持传统记忆
                    if hasattr(self.enhanced_agent, 'basic_agent'):
                        self.enhanced_agent.basic_agent = self

                    # 映射增强智能体的属性到主类（保持兼容性）
                    if hasattr(self.enhanced_agent, 'app'):
                        self.app = self.enhanced_agent.app
                    if hasattr(self.enhanced_agent, 'dingtalk_agent'):
                        self.dingtalk_agent = self.enhanced_agent.dingtalk_agent

                    # 确保 memory 属性存在（增强模式下使用增强记忆）
                    if hasattr(self.enhanced_agent, 'enhanced_memory'):
                        self.memory = self.enhanced_agent.enhanced_memory
                    elif not hasattr(self, 'memory') or self.memory is None:
                        # 如果增强记忆不可用，创建基础记忆
                        self.memory = MemoryClass(memoryKey=self.memorykey, model=self.modelname)

                    self._enhanced_initialized = True
                    print("✅ 增强记忆系统初始化成功")
                except Exception as e:
                    logging.error(f"增强记忆系统初始化失败: {e}")
                    print("⚠️ 降级到基础记忆模式")
                    self.enhanced_mode = False
                    self._enhanced_initialized = False
                    # 确保基础属性存在
                    self._ensure_basic_attributes()

            # 同步初始化（安全版本）
            try:
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                try:
                    loop.run_until_complete(init_async())
                finally:
                    loop.close()
                    asyncio.set_event_loop(None)  # 清理事件循环
            except Exception as e:
                logging.error(f"事件循环初始化失败: {e}")
                print("⚠️ 增强模式初始化失败，使用基础模式")
                self.enhanced_mode = False

        except Exception as e:
            logging.error(f"增强智能体初始化失败: {e}")
            print("⚠️ 降级到基础记忆模式")
            self.enhanced_mode = False
            self._enhanced_initialized = False
            # 确保基础属性存在
            self._ensure_basic_attributes()

    def _init_enhanced_sync(self):
        """同步方式初始化增强模式"""
        try:
            print("🔄 使用同步方式初始化增强记忆功能...")

            # 创建基础的增强记忆组件（不依赖异步）
            from enhanced_memory.enhanced_memory_class import EnhancedMemoryClass

            # 使用简化的同步初始化
            self.enhanced_memory = EnhancedMemoryClass()

            # 创建简化的增强智能体
            class SimpleEnhancedAgent:
                def __init__(self, basic_agent):
                    self.basic_agent = basic_agent

                def run_agent_sync(self, input_text: str, user_id: str = None):
                    # 直接调用基础模式，但保持增强记忆功能
                    return self.basic_agent._run_agent_basic(input_text, user_id)

            self.enhanced_agent = SimpleEnhancedAgent(self)

            # 标记为已初始化
            self._enhanced_initialized = True

            # 初始化基础组件以确保属性存在
            self._init_basic_agent()

            # 确保 memory 属性存在（同步增强模式）
            if hasattr(self.enhanced_agent, 'enhanced_memory'):
                self.memory = self.enhanced_agent.enhanced_memory
            elif not hasattr(self, 'memory') or self.memory is None:
                # 如果增强记忆不可用，使用基础记忆
                self.memory = MemoryClass(memoryKey=self.memorykey, model=self.modelname)

            print("✅ 同步增强记忆模式初始化成功")

        except Exception as e:
            logging.error(f"同步增强模式初始化失败: {e}")
            print(f"❌ 同步增强模式初始化失败: {e}")
            # 保持基础模式
            self.enhanced_mode = False
            self._enhanced_initialized = False
            # 确保基础属性存在
            self._ensure_basic_attributes()

    def _ensure_basic_attributes(self):
        """确保基础属性存在（降级时使用）"""
        try:
            # 确保 memory 属性存在
            if not hasattr(self, 'memory') or self.memory is None:
                try:
                    self.memory = MemoryClass(memoryKey=self.memorykey, model=self.modelname)
                    print("✅ 基础 memory 属性创建成功")
                except Exception as e:
                    logging.error(f"创建基础 memory 失败: {e}")
                    # 设置一个最小的 memory 对象
                    self.memory = type('BasicMemory', (), {
                        'get_memory': lambda _, __: [],
                        'clear': lambda _: True
                    })()

            # 确保 app 属性存在
            if not hasattr(self, 'app') or self.app is None:
                try:
                    # 创建基础工作流
                    self._create_basic_workflow()
                    print("✅ 基础 app 属性创建成功")
                except Exception as e:
                    logging.error(f"创建基础 app 失败: {e}")
                    # 设置一个最小的 app 对象
                    self.app = type('BasicApp', (), {
                        'invoke': lambda _, __: {"output": "基础模式响应", "success": True}
                    })()

            print("✅ 基础属性确保完成")

        except Exception as e:
            logging.error(f"确保基础属性失败: {e}")
            print(f"❌ 确保基础属性失败: {e}")

    def _init_basic_agent(self):
        """初始化基础智能体（原有逻辑）"""
        # 初始化ChatOpenAI模型实例
        from langchain_openai import ChatOpenAI
        self.model = ChatOpenAI(
            model=self.modelname,
            api_key=os.getenv("OPENAI_API_KEY"),
            base_url=os.getenv("OPENAI_BASE_URL")
        )

        # 初始化记忆管理
        self.memory = MemoryClass(memoryKey=self.memorykey, model=self.modelname)

        # 初始化LangGraph记忆检查点
        self.checkpointer = MemorySaver()

        # 初始化Text2SQL智能体
        self.text2sql_agent = get_text2sql_agent().get_agent()

        # 初始化独立的钉钉智能体（无条件集成，自动初始化工具）
        self.dingtalk_agent = None
        try:
            from .dingtalk_agent import create_dingtalk_agent
            # 不传递工具列表，让 DingTalkAgent 自己初始化
            self.dingtalk_agent = create_dingtalk_agent()
            print(f"✅ 独立钉钉智能体初始化成功")
        except Exception as e:
            logging.error(f"钉钉智能体初始化失败: {e}")
            print(f"❌ 钉钉智能体初始化失败: {e}")

        # 初始化知识检索智能体
        self.knowledge_agent = None
        try:
            from knowledge_base.knowledge_agent import create_knowledge_agent
            self.knowledge_agent = create_knowledge_agent()
            print(f"✅ 知识检索智能体初始化成功")
        except Exception as e:
            logging.error(f"知识检索智能体初始化失败: {e}")
            print(f"❌ 知识检索智能体初始化失败: {e}")
            # 创建一个空的钉钉智能体以保持架构一致性
            from .dingtalk_agent import create_dingtalk_agent
            self.dingtalk_agent = create_dingtalk_agent([])

        print("AgentClass initialized with LangGraph Supervisor architecture")

        # 创建基础Supervisor工作流
        self._create_basic_workflow()

        print("Basic Supervisor workflow compiled with memory support")



    def _init_cache_manager(self):
        """初始化简化缓存管理器"""
        try:
            # 简化版本：只使用基础的Redis连接用于响应缓存
            redis_url = os.getenv("REDIS_URL", "redis://localhost:6380/0")
            try:
                from .cache_manager import SimplifiedCacheManager
                self.cache_manager = SimplifiedCacheManager(redis_url)
                self.cache_enabled = self.cache_manager.enabled
                if self.cache_enabled:
                    print("✅ 简化缓存管理器初始化成功")
                else:
                    print("⚠️ 缓存功能禁用")
            except Exception as e:
                logging.warning(f"缓存管理器初始化失败: {e}")
                self.cache_manager = None
                self.cache_enabled = False
                print("❌ 缓存功能不可用")

        except Exception as e:
            logging.error(f"缓存管理器初始化失败: {e}")
            self.cache_manager = None
            self.cache_enabled = False

    def _create_basic_workflow(self):
        """创建简化的基础工作流"""

        # 优化的supervisor prompt - 清晰描述四智能体架构
        supervisor_prompt = """你是钉钉机器人小智，一个专业的AI助手，负责智能路由和协调。

🎯 **你的核心职责**：
1. 智能分析用户请求，准确路由到合适的专业智能体
2. 处理问候和功能介绍
3. 协调多个专业智能体为用户提供服务

🤖 **可用的专业智能体**：
1. **text2sql_agent** - 电影数据库专家：
   - 电影信息查询、演员资料、票房统计
   - 数据分析、分类查询、客户信息
   - 处理所有与电影数据库相关的问题

2. **dingtalk_agent** - 钉钉办公专家：
   - 待办事项管理：创建、查看、完成任务
   - 日程安排：查看日程、创建会议
   - 联系人查询：搜索同事信息
   - 处理所有与钉钉办公相关的功能

3. **knowledge_agent** - 企业知识专家：
   - 公司政策查询：报销流程、请假制度、考勤规定
   - 技术文档检索：API使用、系统配置、故障排查
   - FAQ问答：常见问题解答、操作指南
   - 产品文档：功能说明、使用教程

🔄 **路由原则**：
- 问候和功能介绍：由你直接处理
- 电影/数据库相关：路由到 text2sql_agent
- 钉钉/办公相关：路由到 dingtalk_agent
- 知识/文档/政策相关：路由到 knowledge_agent
- 不确定的查询：默认路由到 text2sql_agent

💬 **交互风格**：
- 保持友好、专业的语调
- 用自然语言回答，避免技术术语
- 主动询问澄清不明确的问题
- 专注于用户价值和解决方案

你的目标是为用户提供最佳的服务体验，通过智能路由确保每个请求都得到最专业的处理。"""

        # 创建简化的supervisor工作流 - 无条件集成三个智能体
        self.workflow = create_supervisor(
            agents=[self.text2sql_agent],
            model=self.model,
            prompt=supervisor_prompt,
            dingtalk_agent=self.dingtalk_agent,  # 无条件传递钉钉智能体
            knowledge_agent=self.knowledge_agent  # 无条件传递知识检索智能体
        )

        # 编译工作流并添加记忆检查点
        self.app = self.workflow.compile(checkpointer=self.checkpointer)

    def run_agent(self, input_text: str, user_id: str = None) -> Dict[str, Any]:
        """
        运行智能体处理用户输入（统一使用增强模式）

        Args:
            input_text: 用户输入文本
            user_id: 用户ID，用于会话管理

        Returns:
            处理结果字典
        """
        # 优先使用增强智能体
        if self.enhanced_mode and self._enhanced_initialized and self.enhanced_agent:
            try:
                return self.enhanced_agent.run_agent_sync(input_text, user_id)
            except Exception as e:
                logging.error(f"增强模式运行失败，降级到基础模式: {e}")

        # 降级到基础模式（保持向后兼容）
        return self._run_agent_basic(input_text, user_id)

    def _run_agent_basic(self, input_text: str, user_id: str = None) -> Dict[str, Any]:
        """
        基础模式运行智能体（增强记忆+缓存集成）
        """
        try:
            # 获取用户ID
            if user_id is None:
                user_id = get_user("userid") or "default_user"

            session_id = f"user_{user_id}"

            # 1. 检查缓存
            cache_key = self._generate_cache_key(input_text, user_id)
            cached_result = None

            if self.cache_enabled and self.cache_manager:
                try:
                    # 简化缓存：直接同步调用
                    cached_result = self.cache_manager.get(f"agent_responses:{cache_key}")
                except Exception as e:
                    logging.warning(f"缓存读取失败: {e}")
                    cached_result = None

                    if cached_result:
                        print(f"🚀 缓存命中: {cache_key[:20]}...")
                        return {
                            **cached_result,
                            "cache_hit": True,
                            "cache_key": cache_key
                        }

                except Exception as e:
                    logging.warning(f"缓存检查失败: {e}")

            # 2. 构建消息列表（简化版本 - Supervisor层已处理上下文）
            messages = [HumanMessage(content=input_text)]

            # 注意：记忆上下文和查询重写现在由Supervisor层统一处理
            # 这避免了重复的上下文处理，提高了系统效率
            logging.info(f"使用简化消息处理，上下文由Supervisor层处理")

            # 4. 构建配置，包含会话ID用于LangGraph记忆管理
            config = {
                "configurable": {
                    "thread_id": session_id  # 使用会话ID作为线程ID
                }
            }

            # 5. 构建初始状态
            initial_state = {
                "messages": messages,
                "user_id": user_id,
                "session_id": session_id
            }

            # 6. 执行工作流
            result = self.app.invoke(initial_state, config)

            # 7. 提取最后的AI回复
            if "messages" in result and result["messages"]:
                last_message = result["messages"][-1]
                output = last_message.content if hasattr(last_message, 'content') else str(last_message)
            else:
                output = "抱歉，我无法处理您的请求。"

            # 8. 保存对话到传统记忆系统（在事件循环关闭前完成）
            try:
                self._save_to_memory(session_id, input_text, output)
                logging.debug(f"记忆保存完成: {session_id}")
            except Exception as memory_e:
                logging.warning(f"记忆保存失败: {memory_e}")

            # 9. 构建响应
            response = {
                "output": output,
                "user_id": user_id,
                "session_id": session_id,
                "success": True,
                "mode": "basic",
                "memory_context_used": False,  # 现在由Supervisor层处理
                "cache_hit": False,
                "cache_key": cache_key
            }

            # 10. 保存到缓存
            self._save_to_cache(cache_key, response)

            return response

        except Exception as e:
            error_message = str(e) if str(e) else "未知错误"
            logging.error(f"Error in sync run_agent: {error_message}")
            print(f"Error in run_agent: {error_message}")
            return {
                "output": f"抱歉，处理您的请求时出现了错误：{error_message}",
                "user_id": user_id or "unknown",
                "success": False,
                "error": error_message,
                "mode": "basic"
            }

    def _get_memory_context(self, session_id: str) -> str:
        """
        获取记忆上下文 - 已弃用

        注意：此方法已被弃用，上下文处理现在由Supervisor层统一处理
        保留此方法仅为向后兼容性
        """
        try:
            # 从传统记忆系统获取历史
            memory_history = self.memory.get_memory(session_id)

            if memory_history and hasattr(memory_history, 'messages') and memory_history.messages:
                # 获取最近的几条对话作为上下文
                recent_messages = memory_history.messages[-6:]  # 最近3轮对话

                context_parts = []
                for msg in recent_messages:
                    if hasattr(msg, 'content'):
                        content = msg.content
                        # 限制每条消息的长度
                        if len(content) > 100:
                            content = content[:100] + "..."

                        if isinstance(msg, HumanMessage):
                            context_parts.append(f"用户: {content}")
                        elif isinstance(msg, AIMessage):
                            context_parts.append(f"助手: {content}")

                if context_parts:
                    # 保留最近2轮对话（4条消息）
                    context = " | ".join(context_parts[-4:])
                    logging.info(f"获取到记忆上下文: {len(context_parts)}条消息")
                    return f"之前的对话: {context}"

            logging.info("没有找到历史对话记录")
            return ""

        except Exception as e:
            logging.warning(f"获取记忆上下文失败: {e}")
            return ""

    def _save_to_memory(self, session_id: str, user_input: str, ai_output: str):
        """保存对话到记忆系统"""
        try:
            # 获取或创建记忆
            memory_history = self.memory.get_memory(session_id)

            # 添加用户消息
            user_message = HumanMessage(content=user_input)
            memory_history.add_message(user_message)
            logging.info(f"保存用户消息: {user_input[:50]}...")

            # 添加AI回复
            ai_message = AIMessage(content=ai_output)
            memory_history.add_message(ai_message)
            logging.info(f"保存AI回复: {ai_output[:50]}...")

            # 保存记忆（RedisChatMessageHistory会自动保存）
            self.memory.save_memory(session_id, memory_history)
            logging.info(f"记忆保存成功，session_id: {session_id}")

        except Exception as e:
            logging.error(f"保存记忆失败: {e}")
            import traceback
            traceback.print_exc()

    def clear_memory(self, user_id: str):
        """清除用户记忆"""
        try:
            session_id = f"user_{user_id}"
            return self.memory.clear_memory(session_id)
        except Exception as e:
            logging.warning(f"清除记忆失败: {e}")
            return False

    def _generate_cache_key(self, input_text: str, user_id: str) -> str:
        """生成缓存键"""
        try:
            # 标准化输入文本（去除空格、转小写）
            normalized_text = input_text.strip().lower()

            # 生成哈希
            content = f"{normalized_text}:{user_id}"
            cache_key = hashlib.md5(content.encode('utf-8')).hexdigest()

            return cache_key

        except Exception as e:
            logging.warning(f"生成缓存键失败: {e}")
            return f"fallback_{hash(input_text)}_{user_id}"

    def _save_to_cache(self, cache_key: str, response: Dict[str, Any]):
        """保存响应到缓存"""
        try:
            if not self.cache_enabled or not self.cache_manager:
                return

            # 准备缓存数据（移除不需要缓存的字段）
            cache_data = {
                "output": response["output"],
                "user_id": response["user_id"],
                "session_id": response["session_id"],
                "success": response["success"],
                "mode": response["mode"],
                "memory_context_used": response.get("memory_context_used", False),
                "cached_at": time.time()
            }

            # 简化缓存：直接同步调用
            self.cache_manager.set(f"agent_responses:{cache_key}", cache_data)

        except Exception as e:
            logging.warning(f"保存缓存失败: {e}")

    def get_cache_stats(self) -> Dict[str, Any]:
        """获取缓存统计信息"""
        try:
            if not self.cache_enabled or not self.cache_manager:
                return {
                    "cache_enabled": False,
                    "message": "缓存功能未启用"
                }

            # 简化版本：只返回基础状态信息
            return {
                "cache_enabled": True,
                "cache_type": "simplified_redis",
                "message": "简化缓存系统运行中"
            }

        except Exception as e:
            logging.error(f"获取缓存统计失败: {e}")
            return {
                "cache_enabled": False,
                "error": str(e)
            }

    def get_conversation_history(self, user_id: str = None) -> list:
        """
        获取用户的对话历史（统一使用增强模式）

        Args:
            user_id: 用户ID

        Returns:
            对话历史列表
        """
        # 优先使用增强智能体
        if self.enhanced_mode and self._enhanced_initialized and self.enhanced_agent:
            try:
                return self._get_conversation_history_enhanced_safe(user_id)
            except Exception as e:
                logging.error(f"增强模式获取历史失败，降级到基础模式: {e}")

        # 降级到基础模式（保持向后兼容）
        return self._get_conversation_history_basic(user_id)

    def _get_conversation_history_enhanced_safe(self, user_id: str = None) -> list:
        """安全的增强模式历史获取（处理事件循环问题）"""
        try:
            # 方法1：检查是否有运行中的事件循环
            try:
                loop = asyncio.get_running_loop()
                # 如果事件循环正在运行，返回空列表避免阻塞
                logging.warning("Event loop is running, cannot get history synchronously")
                return []
            except RuntimeError:
                # 没有运行中的事件循环，继续处理
                pass

            # 方法2：尝试获取或创建事件循环
            try:
                loop = asyncio.get_event_loop()
                if loop.is_running():
                    # 循环正在运行，返回空列表
                    logging.warning("Event loop is running, returning empty history")
                    return []
                else:
                    # 循环存在但未运行，可以安全执行
                    return loop.run_until_complete(self.enhanced_agent.get_conversation_history(user_id))
            except RuntimeError:
                # get_event_loop() 失败，创建新的事件循环
                pass

            # 方法3：创建新的事件循环（最安全的方法）
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            try:
                result = loop.run_until_complete(self.enhanced_agent.get_conversation_history(user_id))
                return result if result else []
            finally:
                # 安全清理事件循环，防止"Event loop is closed"错误
                try:
                    if not loop.is_closed():
                        # 确保所有待处理的任务完成
                        pending = asyncio.all_tasks(loop)
                        if pending:
                            loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                        loop.close()
                    asyncio.set_event_loop(None)
                except Exception as cleanup_e:
                    logging.warning(f"事件循环清理警告: {cleanup_e}")
                    pass

        except Exception as e:
            logging.error(f"增强模式历史获取异常: {e}")
            return []

    def _get_conversation_history_basic(self, user_id: str = None) -> list:
        """基础模式获取对话历史"""
        try:
            if user_id is None:
                user_id = get_user("userid") or "default_user"

            # 使用传统记忆管理获取历史
            session_id = f"user_{user_id}"
            memory_history = self.memory.get_memory(session_id)

            if hasattr(memory_history, 'messages'):
                return memory_history.messages
            elif isinstance(memory_history, list):
                return memory_history
            else:
                return []

        except Exception as e:
            print(f"Error getting conversation history: {e}")
            return []

    def clear_memory(self, user_id: str = None) -> bool:
        """
        清除用户的对话记忆（统一使用增强模式）

        Args:
            user_id: 用户ID

        Returns:
            是否成功清除
        """
        # 优先使用增强智能体
        if self.enhanced_mode and self._enhanced_initialized and self.enhanced_agent:
            try:
                return self._clear_memory_enhanced_safe(user_id)
            except Exception as e:
                logging.error(f"增强模式清除记忆失败，降级到基础模式: {e}")

        # 降级到基础模式（保持向后兼容）
        return self._clear_memory_basic(user_id)

    def _clear_memory_enhanced_safe(self, user_id: str = None) -> bool:
        """安全的增强模式记忆清除（处理事件循环问题）"""
        try:
            # 方法1：尝试获取当前事件循环
            try:
                loop = asyncio.get_running_loop()
                # 如果有运行中的事件循环，创建任务
                asyncio.create_task(self.enhanced_agent.clear_memory(user_id))
                # 注意：在运行中的循环中，我们不能等待任务完成，只能创建任务
                # 这里返回True表示任务已创建，实际清除是异步进行的
                return True
            except RuntimeError:
                # 没有运行中的事件循环，尝试创建新的
                pass

            # 方法2：尝试获取事件循环（可能不在运行）
            try:
                loop = asyncio.get_event_loop()
                if loop.is_running():
                    # 循环正在运行，创建任务
                    asyncio.create_task(self.enhanced_agent.clear_memory(user_id))
                    return True
                else:
                    # 循环存在但未运行，可以安全执行
                    return loop.run_until_complete(self.enhanced_agent.clear_memory(user_id))
            except RuntimeError:
                # get_event_loop() 失败，创建新的事件循环
                pass

            # 方法3：创建新的事件循环（最安全的方法）
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            try:
                result = loop.run_until_complete(self.enhanced_agent.clear_memory(user_id))
                return result
            finally:
                # 安全清理事件循环，防止Redis存储失败
                try:
                    if not loop.is_closed():
                        # 确保所有待处理的任务完成
                        pending = asyncio.all_tasks(loop)
                        if pending:
                            loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
                        loop.close()
                    asyncio.set_event_loop(None)
                except Exception as cleanup_e:
                    logging.warning(f"事件循环清理警告: {cleanup_e}")
                    pass

        except Exception as e:
            logging.error(f"增强模式记忆清除异常: {e}")
            raise e

    def _clear_memory_basic(self, user_id: str = None) -> bool:
        """基础模式清除记忆"""
        try:
            if user_id is None:
                user_id = get_user("userid") or "default_user"

            session_id = f"user_{user_id}"

            # 清除传统记忆（如果存在）
            if hasattr(self, 'memory') and self.memory:
                memory_history = self.memory.get_memory(session_id)
                if hasattr(memory_history, 'clear'):
                    memory_history.clear()
            else:
                # 如果没有基础记忆，尝试直接清除Redis
                try:
                    from langchain_community.chat_message_histories import RedisChatMessageHistory
                    redis_url = os.getenv("REDIS_URL", "redis://localhost:6380/0")
                    chat_history = RedisChatMessageHistory(session_id=session_id, url=redis_url)
                    chat_history.clear()
                except Exception as redis_e:
                    logging.warning(f"Failed to clear Redis memory: {redis_e}")

            print(f"Memory cleared for user: {user_id}")
            return True

        except Exception as e:
            print(f"Error clearing memory: {e}")
            return False

    # 新增增强功能方法
    async def get_user_profile(self, user_id: str = None) -> Dict[str, Any]:
        """获取用户画像 - 已移除，保持接口兼容性"""
        # 用户画像功能已移除，返回空字典保持兼容性
        return {}

    async def get_performance_stats(self) -> Dict[str, Any]:
        """获取性能统计（仅增强模式）"""
        if self.enhanced_mode and self._enhanced_initialized and self.enhanced_agent:
            return await self.enhanced_agent.get_performance_stats()
        else:
            return {
                "mode": "basic",
                "enhanced_features": False,
                "message": "增强功能未启用"
            }

    def get_system_info(self) -> Dict[str, Any]:
        """获取系统信息"""
        return {
            "enhanced_mode": self.enhanced_mode,
            "enhanced_initialized": self._enhanced_initialized,
            "enhanced_available": ENHANCED_MEMORY_AVAILABLE,
            "model": self.modelname,
            "memory_key": self.memorykey,
            "version": "2.0.0-enhanced"
        }